/**
 * Description:
 * Date: 2025-10-11
 * Time: 18:15
 */
public class Test {
    public static void main1(String[] args) {
        System.out.println("hello world!");//字符串常量
        System.out.println(100);//整型常量
        System.out.println(3.14);//浮点型常量
        System.out.println('A');//字符常量
        System.out.println(true);//布尔常量
        System.out.println(false);//布尔常量
    }

    public static void main2(String[] args) {
        //字节型的大小
        System.out.println(Byte.MAX_VALUE);
        System.out.println(Byte.MIN_VALUE);
        //短整型的大小
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE);
        //整型的大小
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //长整型的大小
        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);
        //单精度浮点型的大小
        System.out.println(Float.MAX_VALUE);
        System.out.println(Float.MIN_VALUE);
        //双精度浮点型的大小
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);
        //字符型的大小  注：在java中，此时的Character.MAX_VALUE实际上是个字符
        //              需要强转成整型才能看见数字的大小
        System.out.println((int)Character.MAX_VALUE);
        System.out.println((int)Character.MIN_VALUE);
    }

    public static void main3(String[] args) {
        //byte:是数据类型  a：变量名/标识符  10：变量值
        byte a = 10;//此时表示：一个字节型变量中的值为10
        System.out.println(a);//输出10

        //int：是数据类型    b：变量名/标识符    100：变量值
        int b = 100;//此时表示：一个整型变量a中的值为10
        System.out.println(a);//输出100

        //类似的有......
        double c = 3.14;
        char d = 'A';

        a = 100;//在java中  = 表示赋值
        //该语句表达的意思是将100这个值交给变量a保存，则此时a中的值就是100，而不是10
        System.out.println(a);

        //注意：在一行可以定义多个变量，需要用逗号,隔开
        byte a1 = 1, a2 = 2, a3 = 3;
        System.out.println(a1);//输出1
        System.out.println(a2);//输出2
        System.out.println(a3);//输出3
    }

    public static void main4(String[] args) {
        //使用方式一：在定义变量时给出初始值 （赋值）
        byte a = 10;
        System.out.println(a);

        //使用方式二：在定义时没有给出初始值，但在使用前必须设置一个初始值
        byte b;
        b = 10;
        System.out.println(b);

        //如果按照方式二，若在使用前没有给出初始值，则编译器会报错error
        byte c;
//        System.out.println(c);//error 在这里就已经报错了
        c = 100;

        //byte型变量所能表示的范围
        System.out.println(Byte.MAX_VALUE);//127
        System.out.println(Byte.MIN_VALUE);//-128

        //注意，在定义byte型变量时，所赋值不能超过byte的范围
//        byte d = 128;//error   编译时报错，初始值超过了byte的范围
    }

    public static void main5(String[] args) {
        short a = 10;
        System.out.println(10);//输出10

        //short型变量所能表示的范围
        System.out.println(Short.MAX_VALUE);//32767
        System.out.println(Short.MIN_VALUE);//-32768
    }

    public static void main6(String[] args) {
        int a = 10;
        System.out.println(a);//输出10

        //整型字面常量默认是 int
        System.out.println(100);//如字面常量100的数据类型，在java中就是默认为int

        //int型变量所能表示的范围
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }

    public static void main7(String[] args) {
        int a = 10;
        long b = 100;//这是long定义的长整型变量
        System.out.println(b);//输出100

        //为了区分int和long类型，一般建议：long类型变量的初始值后面加l或者L
        long c = 10l;
        long d = 10L;//一般建议加大写L，因为小写l与1不好区分

        //long型变量所能表示的范围：
        System.out.println(Long.MAX_VALUE);//2^63-1
        System.out.println(Long.MIN_VALUE);//-2^63
    }

    public static void main8(String[] args) {
        double d = 3.14;
        System.out.println(d);//输出3.14

        System.out.println(13.11);//如浮点型字面常量13.11，在java中默认是double

        //测试1：
        int a = 1;
        int b = 2;
        System.out.println(a / b);//会输出0.5吗?
        //在java中int 除以 int 的值仍然是 int(会直接舍弃掉小数部分)
        //则上述代码 (a / b) 所得到的结果是 0

        //若想得到0.5.则需要使用double类型计算
        double a1 = 1;
        double b1 = 2;
        System.out.println(a1 / b1);//结果为 0.5

        //测试2：
        double num = 1.1;
        System.out.println(num * num);//结果会是1.21吗？
        //上述代码的结果是 1.2100000000000002，则表示了浮点数与整数的存储方式是不一样的
    }

    public static void main9(String[] args) {
        float f = 1.0f;//写作1.0F也行
        System.out.println(f);//输出1.0
    }

    public static void main10(String[] args) {
        char c1 = 'A';//英文子母
        char c2 = '1';//数字字符
        System.out.println(c1);//输出A
        System.out.println(c2);//输出1

        //注意：java中的字符可以存放汉字
        char c3 = '语';
        System.out.println(c3);//输出语

        //原因：java中的字符都使用Unicode编码存储
        //'语的Unicode编码是U+8BED(十六进制)，换算成十进制的35821
        //此时说明上述代码是把一个整型数值35821存入了一个char类型的变量中
        System.out.println((int) c3);//输出35821
        System.out.println((int)Character.MAX_VALUE);//输出65535
        System.out.println((int)Character.MIN_VALUE);//输出0
        //也就是说，'语'就是一个整型值35821，而char这个数据类型容纳的Unicode编码的范围是0 ~ 65535，所以可以存进去
        //即：虽然char表示字符，但本质上是保存一个16位(指16个二进制位)的整数
    }

    public static void main11(String[] args) {
        //布尔类型常用来表示真假
        boolean a = true;
        System.out.println(a);//输出true

        boolean b = false;
        System.out.println(b);//输出false
    }

    public static void main12(String[] args) {
        System.out.println(512);//整型默认情况下是int
        System.out.println(3.14);//浮点型默认情况下是double

        int a = 10;
        long b = 100L;
        //a 和 b 都是整型，a的范围小，b的范围大，当将a赋值给b时，编译器会自动将a的类型提升为long类型，然后赋值
        b = a;
        //编译报错，long类型范围比int类型范围大，将b赋值给a，会有数据丢失，不安全
        //a = b;

        float c = 3.14F;
        double d = 5.12;
        d = c;//此时编译器会将c转换为double类型，然后进行赋值
        //c = d;//double类型表示数据范围大，直接将double类型交给float类型会有数据丢失，不安全

        byte b1 = 100;//编译通过，100没有超过byte的范围，编译器隐式将100转换成byte类型
        //byte b2 = 258;//编译失败，258超过了byte的数据类型，有数据丢失
    }

    public static void main13(String[] args) {
        int a = 10;
        long b = 100l;
        b = a;//int-->long，数据范围由小到大，隐式转换
        a = (int) b;//long-->int，数据范围由大到小，需要显示转换(强转)，否则编译失败

        float c = 3.14F;
        double d = 5.12;
        d = c;//float-->double，数据范围由小到大，隐式转换
        c = (float) d;//double-->float，数据范围由大到小，需要强转，否则编译失败

        //a = d;//报错，类型不兼容，需要强转
        a = (int) d;//double-->int,因为int没有double表示的数据范围大，强转之后，小数点之后全部舍弃
        System.out.println(a);//输出3，因为已经将c = 3.14赋值给了d

        byte b1 = 100;//100默认为int，因为100没有超过byte的数据范围，编译器隐式转换成byte类型
        byte b2 = (byte)257;//257超过byte范围，需要强转，否则报错，但因为超出范围，数据不安全，变量b2存的不一定是257
        System.out.println(b2);//如：b2输出的是 2

        boolean fal = true;
        //a =  fal;//报错。类型不兼容，强转也不行
        //fal = a;//报错。类型不兼容，强转也不行
    }

    public static void main14(String[] args) {
        int a = 20;
        long b = 20L;
        //int c = a + b;//编译出错，a+b -->int+long -->long+long，long赋值给int是会丢失数据，需要强转
                     //int类型在与long类型一起运算时，int会提升为long类型后在进行计算
        int c = (int) (a + b);
        System.out.println(c);//输出40
        long d = a + b;//编译成功，a+b -->int+long -->long+long，long类型赋值给long类型
    }

    public static void main(String[] args) {
        byte b1 = 10;
        byte b2 = 20;
        //byte b3 = b1 + b2;//编译出错。计算机在运行低于4个字节计算时，会先将其提升为int类型在计算
                          //此时：b1+b2 -->b1+b2 -->byte+byte -->int+int，int类型赋值给byte会丢失数据，需要强转
        byte b3 = (byte) (b1 + b2);
        System.out.println(b3);//输出30

        int a = b1 + b2;//b1+b2 -->b1+b2 -->byte+byte -->int+int，int类型赋值给int
        System.out.println(a);//输出30
    }
}
